/*
 * @Autor: zwf
 * @Date: 2023-03-03
 * @Version: 1.0
 * @LastEditors: zwf
 * @LastEditTime: 
 * @Description: 布局，模块，菜单，功能，按钮
 **/

import { storage } from "@/utils/storage";
import { arrayToTree, unique } from "@/utils/common";
import router from '../../router';


const types = {
  SET_SETTING_OPENED: "set_setting_opened",
  SET_MENU_OPENED: "set_menu_opened",
  SET_MODULE_CURRENT_ID: "set_module_current_id",
  SET_NODE_DATA: "set_node_data",
  SET_TAG_DATA: 'set_tag_data',
  ADD_TAG_DATA: 'add_tag_data',
  ADD_ROUTES:'add_routes',
  CLEAR: 'clear'
  
};
// state
const state = {
  
  menu: {
    // 菜单是否已经打开
    opened: true,
  },
  setting: {
    opened: false,
  },
  module: {
    // 当前选择模块编码
    currentId: storage.local.get(storage.events.moduleId),
    // single 单模块模式， multiple多模块
    mode: 'multiple', 
  },
  // 节点
  node: storage.local.get(storage.events.node),
  // 打开标签列表, 路由信息;
  tagview: storage.local.get(storage.events.tagview)
};

// getters
const getters = {
  // 获取菜单状
  getSettingOpened(state) {
    return state.setting.opened;
  },
  // 获取菜单状
  getMenuOpened(state) {
    return state.menu.opened;
  },
  // 获取当前选择的模块编码
  getModuleCurrentId(state) {
    return state.module.currentId;
  },
  // 获取模块模式
  getModuleMode(state) {
    return state.module.mode;
  },
  // 获取模块列表数据
  getModuleList(state) {
    let module = [];
    if(state.node.length > 0){
      for(let i in state.node){
        let obj = state.node[i];
        if(obj.node_type == 1){
          module.push(obj)
        }
      }
    }
    // 从小到大排序
    module.sort((a, b) => a.node_sort - b.node_sort);
    return module;
  },
  // 根据当前模块编码获取当前模块下的菜单，按钮，功能
  getCurrentMenuList(state) {
    let menu = [];
    if (state.node.length > 0) {
      let menuList = state.node.filter((item)=>{
        return item.node_type != 4;
      })
      let nodeList = arrayToTree( JSON.parse(JSON.stringify(menuList)) )
      for (let i in nodeList) {
        let obj = nodeList[i];
        // 过滤出当前模块的菜单
        if (obj.code == state.module.currentId) {
          menu = obj.children || [];
        }
      }
    }
    
    // 自动展示选中的菜单
    let  parents = getParents(menu, router.currentRoute.value.path);
    if(parents?.length){
      parents.forEach((item)=>{
        item.show = true
      })
    }

   // 递归排序
    sortTreeData(menu)
    return menu;
  },
  // 获取所有的菜单
  getMenuList(state) {
    let menu = [];
    if (state.node.length > 0) {
      let menuList = state.node.filter((item)=>{
        return item.node_type != 4;
      })
      let nodeList = arrayToTree( JSON.parse(JSON.stringify(menuList)))
      for (let i in nodeList) {
        let obj = nodeList[i];
        menu = menu.concat(obj.children || []);
      }
    }
    return menu;
  },
  // 获取路由tag
  getTagList(state) {
    // todo这里没有过滤掉菜单里面没有的本地数据
    return state.tagview;
  },
  // 获取节点数据
  getNodeData(){
    return state.node;
  },
};

// mutations
const mutations = {
  // 设置菜单是否展开
  [types.SET_SETTING_OPENED](state, flag) {
    state.setting.opened = flag;
  },
  // 设置菜单是否展开
  [types.SET_MENU_OPENED](state, flag) {
    state.menu.opened = flag;
  },
  // 设置模块编码
  [types.SET_MODULE_CURRENT_ID](state, code) {
    state.module.currentId = code;
    storage.local.set(storage.events.moduleId, code);
  },
  // 设置模块菜单数据
  [types.SET_NODE_DATA](state, data)  {
    state.node = data;
    storage.local.set(storage.events.node, data);
  },
  // 添加打开的tag列表
  [types.ADD_TAG_DATA](state, data) {
    // 数组合并
    let arr = [...state.tagview, ...data];
    // 数组去重
    let res = unique(arr)
    state.tagview = res;
    storage.local.set(storage.events.tagview, res);
  },
  // 设置打开的tag列表
  [types.SET_TAG_DATA](state, data) {
    // 数组合并
    let arr = [...data];
    // 数组去重
    let res = unique(arr)
    state.tagview = res;
    storage.local.set(storage.events.tagview, res);
  },
   // 添加路由
  [types.ADD_ROUTES](state, data) {
    if(data.length){
      data.forEach((item)=> {
        if( item.node_type == 3 ){
          // tableList特有视图列表路由，路由禁止命名存在 tableList文案
          if(item.node_router.indexOf('/tableList') == -1) {
            // 组件需要懒加载，不然进入系统就会加载全部页码 todo
            // 是否退出后应该清除原来所有注册过的路由， todo
            if(item.node_router) {
              router.addRoute('layout', {
                name: item.node_router.replace(/\//g,'-').replace(/^-/, ''),
                path: item.node_router,
                meta: {
                  title: item.node_name,
                  keepAlive:item.node_cache == 1 ? true: false
                },
                component: () => import(`@/views${item.node_template}.vue`)
              });
            }
          }     
        }
      })
    }
  },
  // 清除
  [types.CLEAR](state) {
    // 清除打开的tagview
    state.tagview  =[];
    state.module.currentId = ''
  },
};

// actions
const actions = {
  // 设置是否显示
  setSettingOpened({ commit }, flag) {
    commit(types.SET_SETTING_OPENED, flag);
  },
  // 设置菜单是否展开
  setMenuOpened({ commit }, flag) {
    commit(types.SET_MENU_OPENED, flag);
  },
  // 设置模块编码
  setModuleCurrentId({ commit }, id) {
    commit(types.SET_MODULE_CURRENT_ID, id);
  },
  // 设置模块菜单数据
  setNodeData({ commit }, data) {
    commit(types.SET_NODE_DATA, data);
  },
  // 设置打开的tag列表
  setTagData({ commit }, data) {
    commit(types.SET_TAG_DATA, data);
  },
   // 添加打开的tag列表
  addTagData({ commit }, data) {
    commit(types.ADD_TAG_DATA, data);
  },
  /*
  *@method 批量注册动态路由
  *@param  routes  菜单列表
  *@return
  */
  addRoutes({ commit }, data){
    commit(types.ADD_ROUTES, data);
  },
  initRoutes({ commit, state }) {
    let nodes = storage.local.get(storage.events.node)
    commit(types.ADD_ROUTES, nodes);
  },
  init({ commit, getters }){
    let data = getters.getModuleList;
    // 清除打开的tagview, 初始化选中的模块
    if(data?.length){
      commit(types.SET_MODULE_CURRENT_ID,  data[0].code);
    }
  },
  clear({ commit }){
    commit(types.CLEAR);
  },
};
/*
*@method 菜单递归排序
*@param  menu  菜单树
*@return
*/
function sortTreeData(menu) {
  if(menu.length > 0 ){
    menu.sort((a, b) => a.node_sort - b.node_sort);
    menu.forEach(item => {
      if(item.children?.length){
        sortTreeData(item.children)
      }
    })
  }
}
/*
*@method 获取所有父级节点
*@param  list  菜单树
*@param  path  当前路由
*@return
*/
function getParents(list, path) {
  for (let i in list) {
      let item = list[i];
      if (item.node_router == path) return [item];
      if (item.children) {
        let node = getParents(item.children, path)
        if (node !== undefined) return node.concat(item)
    }
  }
}
const layout = {
  namespaced: true,
  state,
  getters,
  actions,
  mutations,
};

export default layout;
